#ifndef _NE_RENDER_SYSTEM_DEFINE_H_
#define _NE_RENDER_SYSTEM_DEFINE_H_

#include <neinit.h>
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
    #include <GL/glew.h>
#else
    #include <OpenGLES/ES2/gl.h>
    #include <OpenGLES/ES2/glext.h>
#endif

#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
#else
#endif

namespace ne
{
    enum GLDataType
    {
        GLDT_CHAR = GL_BYTE,
        GLDT_BYTE = GL_UNSIGNED_BYTE,
        GLDT_SHORT = GL_SHORT,
        GLDT_UNSIGNED_SHORT = GL_UNSIGNED_SHORT,
        GLDT_INT = GL_INT,
        GLDT_UNSIGNED_INT = GL_UNSIGNED_INT,
        GLDT_FLOAT = GL_FLOAT,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        GLDT_DOUBLE = GL_DOUBLE,
#else
        GLDT_DOUBLE = 0x140A,
#endif
    };

    enum BufferBitType
    {
        BBT_COLOR_BUFFER_BIT = GL_COLOR_BUFFER_BIT,
        BBT_DEPTH_BUFFER_BIT = GL_DEPTH_BUFFER_BIT,
        BBT_STENCIL_BUFFER_BIT = GL_STENCIL_BUFFER_BIT,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        BBT_ACCUM_BUFFER_BIT = GL_ACCUM_BUFFER_BIT,
#else
        BBT_ACCUM_BUFFER_BIT = 0x00000200,
#endif
    };

    enum TransformMatrixMode
    {
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        TMT_VIEW = GL_MODELVIEW,
        TMT_PROJECTION = GL_PROJECTION,
        TMT_TEXTURE = GL_TEXTURE,
        TMT_COLOR = GL_COLOR,
#else
        TMT_VIEW = 0x1700,
        TMT_PROJECTION = 0x1701,
        TMT_TEXTURE = 0x1702,
        TMT_COLOR = 0x1800,
#endif
    };

    enum TransformMatrixType
    {
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        TMT_VIEW_MATRIX = GL_MODELVIEW_MATRIX,
        TMT_PROJECTION_MATRIX = GL_PROJECTION_MATRIX,
        TMT_TEXTURE_MATRIX = GL_TEXTURE_MATRIX,
        TMT_COLOR_MATRIX = GL_COLOR_MATRIX,
#else
        TMT_VIEW_MATRIX = 0x0BA6,
        TMT_PROJECTION_MATRIX = 0x0BA7,
        TMT_TEXTURE_MATRIX = 0x0BA8,
        TMT_COLOR_MATRIX = 0x80B1,
#endif
    };

    enum TestType
    {
        TT_DEPTH_TEST = GL_DEPTH_TEST,
        TT_STENCIL_TEST = GL_STENCIL_TEST,
        TT_SCISSOR_TEST = GL_SCISSOR_TEST,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        TT_ALPHA_TEST = GL_ALPHA_TEST,
#else
        TT_ALPHA_TEST = 0x0BC0,
#endif
    };

    enum FrontFaceType
    {
        FFT_CCW = GL_CCW,
        FFT_CW = GL_CW,
    };

    enum FaceType
    {
        FT_FRONT = GL_FRONT,
        FT_BACK = GL_BACK,
        FT_BOTH = GL_FRONT_AND_BACK,
    };

    enum ColorMask
    {
        CM_NONE = 0x0,
        CM_R = 0x1,
        CM_G = 0x2,
        CM_B = 0x4,
        CM_A = 0x8,
        CM_RGB = 0x7,
        CM_RGBA = 0xF,
    };

    enum PixelBufferType
    {
        PBT_FRONT = GL_FRONT,
        PBT_BACK = GL_BACK,
        PBT_FRONT_AND_BACK = GL_FRONT_AND_BACK,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        PBT_LEFT = GL_LEFT,
        PBT_RIGHT = GL_RIGHT,
        PBT_FRONT_LEFT = GL_FRONT_LEFT,
        PBT_FRONT_RIGHT = GL_FRONT_RIGHT,
        PBT_BACK_LEFT = GL_BACK_LEFT,
        PBT_BACK_RIGHT = GL_BACK_RIGHT,
#else
        PBT_LEFT = 0x0406,
        PBT_RIGHT = 0x0407,
        PBT_FRONT_LEFT = 0x0400,
        PBT_FRONT_RIGHT = 0x0401,
        PBT_BACK_LEFT = 0x0402,
        PBT_BACK_RIGHT = 0x0403,
#endif
    };

    enum PolygonMode
    {
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        PM_POINT = GL_POINT,
        PM_LINE = GL_LINE,
        PM_FILL = GL_FILL,
#else
        PM_POINT = 0x1B00,
        PM_LINE = 0x1B01,
        PM_FILL = 0x1B02,
#endif
    };

    enum CompareFunction
    {
        CF_NEVER = GL_NEVER,
        CF_LEQUAL = GL_LEQUAL,
        CF_GEQUAL = GL_GEQUAL,
        CF_LESS = GL_LESS,
        CF_GREATER = GL_GREATER,
        CF_EQUAL = GL_EQUAL,
        CF_NOTEQUAL = GL_NOTEQUAL,
        CF_ALWAYS = GL_ALWAYS,
    };

    enum StencilOperation
    {
        SO_ZERO = GL_ZERO,
        SO_KEEP = GL_KEEP,
        SO_REPLACE = GL_REPLACE,
        SO_INCR = GL_INCR,
        SO_DECR = GL_DECR,
        SO_INVERT = GL_INVERT,
        SO_INCR_WRAP = GL_INCR_WRAP,
        SO_DECR_WRAP = GL_DECR_WRAP,
    };

    enum BlendEquation
    {
        BE_ADD = GL_FUNC_ADD,
        BE_SUBTRACT = GL_FUNC_SUBTRACT,
        BE_REVERSE_SUBTRACT = GL_FUNC_REVERSE_SUBTRACT,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        BE_MIN = GL_MIN,
        BE_MAX = GL_MAX,
#else
        BE_MIN = 0x8007,
        BE_MAX = 0x8008,
#endif
    };

    enum BlendFunction
    {
        BF_ZERO = GL_ZERO,
        BF_ONE = GL_ONE,
        BF_SRC_COLOR = GL_SRC_COLOR,
        BF_ONE_MINUS_SRC_COLOR = GL_ONE_MINUS_SRC_COLOR,
        BF_SRC_ALPHA = GL_SRC_ALPHA,
        BF_ONE_MINUS_SRC_ALPHA = GL_ONE_MINUS_SRC_ALPHA,
        BF_DST_ALPHA = GL_DST_ALPHA,
        BF_ONE_MINUS_DST_ALPHA = GL_ONE_MINUS_DST_ALPHA,
        BF_DST_COLOR = GL_DST_COLOR,
        BF_ONE_MINUS_DST_COLOR = GL_ONE_MINUS_DST_COLOR,
        BF_CONSTANT_COLOR = GL_CONSTANT_COLOR,
        BF_ONE_MINUS_CONSTANT_COLOR = GL_ONE_MINUS_CONSTANT_COLOR,
        BF_CONSTANT_ALPHA = GL_CONSTANT_ALPHA,
        BF_ONE_MINUS_CONSTANT_ALPHA = GL_ONE_MINUS_CONSTANT_ALPHA,
        BF_BLEND_COLOR = GL_BLEND_COLOR,
        // TODO: BF_SRC_ALPHA_SATURATE only can use for source
        BF_SRC_ALPHA_SATURATE = GL_SRC_ALPHA_SATURATE,
    };

    enum HintMode
    {
        HM_DONT_CARE = GL_DONT_CARE,
        HM_FASTEST = GL_FASTEST,
        HM_NICEST = GL_NICEST,
    };

    enum PrimitiveType
    {
        PT_POINTS = GL_POINTS,
        PT_LINES = GL_LINES,
        PT_LINE_STRIP = GL_LINE_STRIP,
        PT_LINE_LOOP = GL_LINE_LOOP,
        PT_TRIANGLES = GL_TRIANGLES,
        PT_TRIANGLE_STRIP = GL_TRIANGLE_STRIP,
        PT_TRIANGLE_FAN = GL_TRIANGLE_FAN,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        PT_QUADS = GL_QUADS,
        PT_QUAD_STRIP = GL_QUAD_STRIP,
        PT_POLYGON = GL_POLYGON,
#else
        PT_QUADS = 0x0007,
        PT_QUAD_STRIP = 0x0008,
        PT_POLYGON = 0x0009,
#endif
    };

    enum AttributeSemantic
    {
        // Builtin attribute semantic
        VAS_POSITION = 0,
        VAS_NORMAL = 2,
        VAS_COLOR = 3,
        VAS_SECONDARY_COLOR = 4,
        VAS_FOG_COORD = 5,
        VAS_EDGE_FLAG = 6,
        VAS_TEXTURE_COORD = 8,
        VAS_TEXTURE_COORD0 = 8,
        VAS_TEXTURE_COORD1 = 9,
        VAS_TEXTURE_COORD2 = 10,
        VAS_TEXTURE_COORD3 = 11,
        VAS_TEXTURE_COORD4 = 12,
        VAS_TEXTURE_COORD5 = 13,
        VAS_TEXTURE_COORD6 = 14,
        VAS_TEXTURE_COORD7 = 15,

        // Custom attribute semantic
        VAS_BLEND_WEIGHT = 1,
        VAS_BLEND_INDEX = 7,
        VAS_ATTRIBUTE = 10,
        VAS_ATTRIBUTE0 = 10,
        VAS_ATTRIBUTE1 = 11,
        VAS_ATTRIBUTE2 = 12,
        VAS_ATTRIBUTE3 = 13,
        VAS_ATTRIBUTE4 = 14,
        VAS_ATTRIBUTE5 = 15,
        VAS_TANGENT = 14,
        VAS_BINORMAL = 15,

        VAS_INDEX = 16,
    };

    enum AttributeType
    {
        VAT_CHAR = 0,
        VAT_CHAR1 = 0,
        VAT_CHAR2 = 1,
        VAT_CHAR3 = 2,
        VAT_CHAR4 = 3,

        VAT_BYTE = 4,
        VAT_BYTE1 = 4,
        VAT_BYTE2 = 5,
        VAT_BYTE3 = 6,
        VAT_BYTE4 = 7,

        VAT_RGB = 6,
        VAT_RGBA = 7,

        VAT_SHORT = 8,
        VAT_SHORT1 = 8,
        VAT_SHORT2 = 9,
        VAT_SHORT3 = 10,
        VAT_SHORT4 = 11,

        VAT_UNSIGNED_SHORT = 12,
        VAT_UNSIGNED_SHORT1 = 12,
        VAT_UNSIGNED_SHORT2 = 13,
        VAT_UNSIGNED_SHORT3 = 14,
        VAT_UNSIGNED_SHORT4 = 15,

        VAT_INT = 16,
        VAT_INT1 = 16,
        VAT_INT2 = 17,
        VAT_INT3 = 18,
        VAT_INT4 = 19,

        VAT_UNSIGNED_INT = 20,
        VAT_UNSIGNED_INT1 = 20,
        VAT_UNSIGNED_INT2 = 21,
        VAT_UNSIGNED_INT3 = 22,
        VAT_UNSIGNED_INT4 = 23,

        VAT_FLOAT = 24,
        VAT_FLOAT1 = 24,
        VAT_FLOAT2 = 25,
        VAT_FLOAT3 = 26,
        VAT_FLOAT4 = 27,

        VAT_COLOR_RGB = 26,
        VAT_COLOR_RGBA = 27,

        VAT_DOUBLE = 28,
        VAT_DOUBLE1 = 28,
        VAT_DOUBLE2 = 29,
        VAT_DOUBLE3 = 30,
        VAT_DOUBLE4 = 31,
    };

    // Light
    enum LightType
    {
        LT_POINT = 0,
        LT_DIRECTIONAL = 1,
        LT_SPOTLIGHT = 2,
    };

    enum LightAttenuationType
    {
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        LAT_CONSTANT = GL_CONSTANT_ATTENUATION,
        LAT_LINEAR = GL_LINEAR_ATTENUATION,
        LAT_QUADRATIC = GL_QUADRATIC_ATTENUATION,
#else
        LAT_CONSTANT = 0x1207,
        LAT_LINEAR = 0x1208,
        LAT_QUADRATIC = 0x1209,
#endif
    };

    // Fog
    enum FogMode
    {
        FM_LINEAR = GL_LINEAR, // f = (end - c) / (end - start)
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        FM_EXP = GL_EXP,       // f = exp(-density * c)
        FM_EXP2 = GL_EXP2,     // f = exp(-(density * c)^2)
#else
        FM_EXP = 0x0800,
        FM_EXP2 = 0x0801,
#endif
    };

    enum FogCoordMode
    {
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        FCM_COORD = GL_FOG_COORD,
        FCM_DEPTH = GL_FRAGMENT_DEPTH,
#else
        FCM_COORD = 0x8451,
        FCM_DEPTH = 0x8452,
#endif
    };

    // Pixel
    enum PixelFormat
    {
        PF_UNKNOWN = 0,
        PF_ALPHA = GL_ALPHA,
        PF_LUMINANCE = GL_LUMINANCE,
        PF_LUMINANCE_ALPHA = GL_LUMINANCE_ALPHA,
        PF_RGB = GL_RGB,
        PF_RGBA = GL_RGBA,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        PF_RED = GL_RED,
        PF_GREEN = GL_GREEN,
        PF_BLUE = GL_BLUE,
        PF_BGR = GL_BGR,
        PF_BGRA = GL_BGRA,
        PF_BITMAP = GL_BITMAP,
#else
        PF_RED = 0x1903,
        PF_GREEN = 0x1904,
        PF_BLUE = 0x1905,
        PF_BGR = 0x80E0,
        PF_BGRA = 0x80E1,
        PF_BITMAP = 0x1A00,
#endif
    };

    enum PixelType
    {
        PT_BYTE = GL_BYTE,
        PT_UNSIGNED_BYTE = GL_UNSIGNED_BYTE,
        PT_SHORT = GL_SHORT,
        PT_UNSIGNED_SHORT = GL_UNSIGNED_SHORT,
        PT_INT = GL_INT,
        PT_UNSIGNED_INT = GL_UNSIGNED_INT,
        PT_FLOAT = GL_FLOAT,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        PT_BITMAP = GL_BITMAP,
#else
        PT_BITMAP = 0x1A00,
#endif
    };

    // Texture
    enum TextureType
    {
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        TT_1D = GL_TEXTURE_1D,
#else
        TT_1D = 0x0DE0,
#endif
        TT_2D = GL_TEXTURE_2D,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        TT_3D = GL_TEXTURE_3D,
        TT_1D_ARRAY = GL_TEXTURE_1D_ARRAY,
        TT_2D_ARRAY = GL_TEXTURE_2D_ARRAY,
#else
        TT_3D = 0x806F,
        TT_1D_ARRAY = 0x8C18,
        TT_2D_ARRAY = 0x8C1A,
#endif
        //TT_RECTANGLE = GL_TEXTURE_RECTANGLE,
        //TT_BUFFER = GL_TEXTURE_BUFFER,
        //TT_2D_MULTISAMPLE = GL_TEXTURE_2D_MULTISAMPLE,
        //TT_2D_MULTISAMPLE_ARRAY = GL_TEXTURE_2D_MULTISAMPLE_ARRAY,
        TT_CUBE_MAP = GL_TEXTURE_CUBE_MAP,
    };

    enum TextureFormat
    {
        TF_DEPTH_COMPONENT = GL_DEPTH_COMPONENT,
        TF_ALPHA = GL_ALPHA,
        TF_LUMINANCE = GL_LUMINANCE,
        TF_LUMINANCE_ALPHA = GL_LUMINANCE_ALPHA,
        TF_RGB = GL_RGB,
        TF_RGBA = GL_RGBA,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        TF_SLUMINANCE = GL_SLUMINANCE,
        TF_SLUMINANCE_ALPHA = GL_SLUMINANCE_ALPHA,
        TF_SRGB = GL_SRGB,
        TF_SRGB_ALPHA = GL_SRGB_ALPHA,
        TF_INTENSITY = GL_INTENSITY,

        TF_COMPRESSED_ALPHA = GL_COMPRESSED_ALPHA,
        TF_COMPRESSED_LUMINANCE = GL_COMPRESSED_LUMINANCE,
        TF_COMPRESSED_LUMINANCE_ALPHA = GL_COMPRESSED_LUMINANCE_ALPHA,
        TF_COMPRESSED_RGB = GL_COMPRESSED_RGB,
        TF_COMPRESSED_RGBA = GL_COMPRESSED_RGBA,
        TF_COMPRESSED_SLUMINANCE = GL_COMPRESSED_SLUMINANCE,
        TF_COMPRESSED_SLUMINANCE_ALPHA = GL_COMPRESSED_SLUMINANCE_ALPHA,
        TF_COMPRESSED_SRGB = GL_COMPRESSED_SRGB,
        TF_COMPRESSED_SRGB_ALPHA = GL_COMPRESSED_SRGB_ALPHA,
        TF_COMPRESSED_INTENSITY = GL_COMPRESSED_INTENSITY,
#endif
    };

    enum TextureFilterFunc
    {
        TFF_NEAREST = GL_NEAREST,
        TFF_LINEAR = GL_LINEAR,
        TFF_NEAREST_MIPMAP_NEAREST = GL_NEAREST_MIPMAP_NEAREST,
        TFF_NEAREST_MIPMAP_LINEAR = GL_NEAREST_MIPMAP_LINEAR,
        TFF_LINEAR_MIPMAP_NEAREST = GL_LINEAR_MIPMAP_NEAREST,
        TFF_LINEAR_MIPMAP_LINEAR = GL_LINEAR_MIPMAP_LINEAR,
    };

    enum TextureWrapParameter
    {
        TWP_REPEAT = GL_REPEAT,
        TWP_CLAMP_TO_EDGE = GL_CLAMP_TO_EDGE,
        TWP_MIRRORED_REPEAT = GL_MIRRORED_REPEAT,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        TWP_CLAMP = GL_CLAMP,
        TWP_CLAMP_TO_BORDER = GL_CLAMP_TO_BORDER,
#else
        TWP_CLAMP = 0x2900,
        TWP_CLAMP_TO_BORDER = 0x812D,
#endif
    };

    enum TextureCompareMode
    {
        TCM_NONE = GL_NONE,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        TCM_COMPARE_R_TO_TEXTURE = GL_COMPARE_R_TO_TEXTURE,
#else
        TCM_COMPARE_R_TO_TEXTURE = 0x884E,
#endif
    };

    enum TextureCompareFunc
    {
        TCF_NEVER = GL_NEVER,
        TCF_LEQUAL = GL_LEQUAL,
        TCF_GEQUAL = GL_GEQUAL,
        TCF_LESS = GL_LESS,
        TCF_GREATER = GL_GREATER,
        TCF_EQUAL = GL_EQUAL,
        TCF_NOTEQUAL = GL_NOTEQUAL,
        TCF_ALWAYS = GL_ALWAYS,
    };

    enum TextureDepthTextureMode
    {
        TDTM_ALPHA = GL_ALPHA,
        TDTM_LUMINANCE = GL_LUMINANCE,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        TDTM_INTENSITY = GL_INTENSITY,
#else
        TDTM_INTENSITY = 0x8049,
#endif
    };

    /*===================================================
                    Cube Map Face
                               ____
                              | -Y |
                     _________|____|____
                    | -Z | -X | +Z | +X |
                    |____|____|____|____|
                              | +Y |
                              |____|
    ===================================================*/
    enum TextureCubeMapFace
    {
        TCMF_POSITIVE_X = GL_TEXTURE_CUBE_MAP_POSITIVE_X,
        TCMF_NEGATIVE_X = GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
        TCMF_POSITIVE_Y = GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
        TCMF_NEGATIVE_Y = GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
        TCMF_POSITIVE_Z = GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
        TCMF_NEGATIVE_Z = GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
    };

    // Buffer Object
    enum BufferType
    {
        BOT_ARRAY_BUFFER = GL_ARRAY_BUFFER,
        BOT_ELEMENT_ARRAY_BUFFER = GL_ELEMENT_ARRAY_BUFFER,
        BOT_ARRAY_BUFFER_BINDING = GL_ARRAY_BUFFER_BINDING,
        BOT_ELEMENT_ARRAY_BUFFER_BINDING = GL_ELEMENT_ARRAY_BUFFER_BINDING,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        BOT_PIXEL_PACK_BUFFER = GL_PIXEL_PACK_BUFFER,
        BOT_PIXEL_UNPACK_BUFFER = GL_PIXEL_UNPACK_BUFFER,
        BOT_PIXEL_PACK_BUFFER_BINDING = GL_PIXEL_PACK_BUFFER_BINDING,
        BOT_PIXEL_UNPACK_BUFFER_BINDING = GL_PIXEL_UNPACK_BUFFER_BINDING,
        BOT_TEXTURE_BUFFER = GL_TEXTURE_BUFFER,
        BOT_TRANSFORM_FEEDBACK_BUFFER = GL_TRANSFORM_FEEDBACK_BUFFER,
        BOT_UNIFORM_BUFFER = GL_UNIFORM_BUFFER,
#endif
    };

    enum BufferUsage
    {
        BOU_STREAM_DRAW = GL_STREAM_DRAW,
        BOU_STATIC_DRAW = GL_STATIC_DRAW,
        BOU_DYNAMIC_DRAW = GL_DYNAMIC_DRAW,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        BOU_STREAM_READ = GL_STREAM_READ,
        BOU_STATIC_READ = GL_STATIC_READ,
        BOU_DYNAMIC_READ = GL_DYNAMIC_READ,
        BOU_STREAM_COPY = GL_STREAM_COPY,
        BOU_STATIC_COPY = GL_STATIC_COPY,
        BOU_DYNAMIC_COPY = GL_DYNAMIC_COPY,
#endif
    };

    enum BufferAccess
    {
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        BOA_READ_ONLY = GL_READ_ONLY,
        BOA_WRITE_ONLY = GL_WRITE_ONLY,
        BOA_READ_WRITE = GL_READ_WRITE,
#else
        BOA_READ_ONLY = 0x88B8,
        BOA_WRITE_ONLY = 0x88B9,
        BOA_READ_WRITE = 0x88BA,
#endif
    };

    enum FrameBufferUsage
    {
        FBOU_NORMAL = GL_FRAMEBUFFER,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        FBOU_READ = GL_READ_FRAMEBUFFER,
        FBOU_DRAW = GL_DRAW_FRAMEBUFFER,
#else
        FBOU_READ = 0x8CA8,
        FBOU_DRAW = 0x8CA9,
#endif
    };

    enum FrameBufferAttachment
    {
        FBOA_COLOR = GL_COLOR_ATTACHMENT0,
        FBOA_DEPTH = GL_DEPTH_ATTACHMENT,
        FBOA_STENCIL = GL_STENCIL_ATTACHMENT,
    };

    // Shader
    enum ShaderType
    {
        SHADER_TYPE_VERTEX = GL_VERTEX_SHADER,
        SHADER_TYPE_FRAGMENT = GL_FRAGMENT_SHADER,
#if NE_RENDER_SYSTEM == NE_RENDER_SYSTEM_OPENGL
        SHADER_TYPE_GEOMETRY = GL_GEOMETRY_SHADER,
#else
        SHADER_TYPE_GEOMETRY = 0x8DD9,
#endif
    };
}

#endif
